home *** CD-ROM | disk | FTP | other *** search
/ Power Programmierung 2 / Power-Programmierung CD 2 (Tewi)(1994).iso / c / tools / make / nmake / machdep.c next >
Encoding:
C/C++ Source or Header  |  1987-07-21  |  10.4 KB  |  558 lines
  1. /* bdos utilities */
  2. #include <stdio.h>
  3. #include "make.h"
  4.  
  5. #if MSC
  6. #include <process.h>
  7. #include <ctype.h>
  8. #endif
  9.  
  10. #if CI86
  11. /* bdos function defs */
  12.  
  13. #define O_FIND_FIRST 0x4E00
  14. #define O_FIND_NEXT 0x4F
  15. #define O_SET_DTA 0x1A
  16. #define O_RET_CODE 0x4d
  17.  
  18. struct regval {
  19.     unsigned ax, bx, cx, dx, si, di, ds, es;
  20. };
  21.  
  22. struct segs {
  23.     unsigned scs, sss, sds, ses;
  24. };
  25.  
  26. extern char *DRIVE;
  27. struct dta  dta;
  28.  
  29. find_next() 
  30. {
  31.     return(bdos(O_FIND_NEXT,0));
  32. }
  33.  
  34. err_code()
  35. {
  36.     return(bdos(O_RET_CODE,0));
  37. }
  38.  
  39. find_first(name)
  40. unsigned char *name;
  41. {
  42. struct regval  srv;
  43. struct segs    rv;
  44. unsigned char  *kludge;
  45.  
  46.     set_dta();
  47.     kludge = name;
  48.     while(*kludge){
  49.         if(isspace(*kludge)) {
  50.             *kludge = NUL;
  51.             break;
  52.         }
  53.         else kludge++;
  54.     }
  55.     segread(&rv);
  56.     srv.ds = rv.sds;
  57.     srv.es = rv.ses;
  58.     srv.cx = 0;
  59.     srv.ax = (O_FIND_FIRST);
  60.     srv.dx = (unsigned int )name;
  61.     return ( sysint21(&srv,&srv) & 1);
  62. }
  63.  
  64. /* the following function must be called prior to using the 
  65.    file date/time function 
  66. */
  67. set_dta()
  68. {
  69.     bdos(O_SET_DTA,&dta);
  70.     return;
  71. }
  72.  
  73. char temp[20];
  74.  
  75. badsys(bname,code)
  76. int code;
  77. char *bname;
  78. {
  79.  
  80.     switch (code) {
  81.     
  82.     case 1:
  83.        error("'%s' not found",bname);
  84.        break;
  85.  
  86.     case 2:
  87.        error("system: COMSPEC not found");
  88.        break;
  89.  
  90.     case 8:
  91.        error("system\(\): insufficient memory");
  92.        break;
  93.  
  94.     default:
  95.        sprintf(temp,"%d",code);
  96.        error("error %s from 'system' call",temp);
  97.        break;
  98.     }
  99. }
  100.  
  101.  
  102. baddo_sys(bname,code)
  103. int code;
  104. char *bname;
  105. {
  106.     switch (code) {
  107.     
  108.     case 1:
  109.        error("file not found");
  110.        break;
  111.  
  112.     case 2:
  113.        error("Can't find '%s'",bname);
  114.        break;
  115.     
  116.     case 3:
  117.         error("Command too long");
  118.         break;
  119.  
  120.     case 8:
  121.        error("do_sys\(\): insufficient memory");
  122.        break;
  123.  
  124.     default:
  125.        sprintf(temp,"%d",code);
  126.        error2("DOS error %s from '%s' call",temp,bname);
  127.        break;
  128.     }
  129. }
  130.  
  131. /* what follows is the 'system' command as given in the c86 library,
  132.    munged to accept full pathnames ( this ain't much changed from the 
  133.    original, so I accept no blame )
  134. */
  135. /*  run a program under the system function
  136.     returns zero if succesful
  137. */
  138.  
  139. #if _C86_BIG
  140.  
  141. do_sys(prog,args)
  142. unsigned char *prog,*args;
  143. {
  144.    panic("panic: This program should be compiled with the SMALL model");
  145. }
  146.  
  147. #else
  148.  
  149. do_sys(prog,args)
  150. unsigned char *prog,*args;
  151. {
  152.  
  153.   struct regval srv;
  154.   struct {
  155.     int env_seg;
  156.     char *line_off,*line_seg;
  157.     char *fcb1_off,*fcb1_seg;
  158.     char *fcb2_off,*fcb2_seg;
  159.   } ctrl;
  160.   unsigned char cline[128],newname[128];
  161.   strcpy(newname,DRIVE);
  162.   strcat(newname,prog);
  163.   uppercase(newname);
  164.  
  165.   if( strlen(prog)+strlen(args) > 123 )return( 3 );  /* too  long to use */
  166.   srv.ax=0x4800;
  167.   srv.bx=0xfff0;            /* look for a lot of memory */
  168.   if((sysint21(&srv,&srv)&1) && srv.bx<(64*17)) return( 8 );
  169.   cline[0]=strlen(args);
  170.   strcpy(cline+1,args);
  171.   segread(&srv.si);
  172.   ctrl.env_seg=0;
  173.   ctrl.line_off=cline;
  174.   ctrl.line_seg=srv.ds;
  175.   return( loadexec(newname,srv.ds,&ctrl,srv.ds,0) );
  176.  
  177. }
  178.  
  179. #endif
  180.  
  181. long now()
  182. {
  183. struct regval srv;
  184. int    date[4];
  185. long   ldate;
  186.  
  187.     srv.ax = 0x2a00;            /* get system date */
  188.     sysint21(&srv,&srv);
  189.     date[0] = srv.cx;
  190.     date[1] = srv.dx;
  191.     
  192.     srv.ax = 0x2c00;            /* get sytem time  */
  193.     sysint21(&srv,&srv);
  194.     date[2] = srv.cx;
  195.     date[3] = srv.dx;
  196.     
  197.     ldate = (long)(0x7F & (date[0] - 1980)); /* year - 1980 */
  198.     ldate <<= 4;
  199.     ldate += (long)(0xF & (date[1] >> 8));   /* month */
  200.     ldate <<= 5;
  201.     ldate += (long)(0x1F & date[1]);         /* day */
  202.     ldate <<= 5;
  203.     ldate += (long)(0x1F & (date[2] >> 8));  /* hour */
  204.     ldate <<= 6;
  205.     ldate += (long)(0x3F & date[2]);         /* minute */
  206.     ldate <<= 5;
  207.     ldate += (long)(0x1E & (date[3] >> 7));  /* seconds * 2 */
  208.     return( ldate );
  209. }
  210.  
  211.  
  212. #endif
  213.  
  214.  
  215. #if UNIX
  216. /* just some stuff to make it compile on the VAX, for debugging */
  217. find_next(){return(1);}
  218. isspace(c) char c;{return (c == ' '||c == '\t'||c == '\n');}
  219. toupper(c)char c;{return ( (c >= 'a' && c <= 'z') ? c + 'A' - 'a' : c);}
  220. system(){printf("system call \n");}
  221. do_sys(){printf("do_sys call \n");}
  222. badsys(x){printf("bad system call\n");}
  223. baddo_sys(x){printf("bad do_sys call\n");}
  224. err_code(){return(0);}
  225. struct dta dta;
  226. find_first(){printf("finding first\n");}
  227. now(){return(0);}
  228. #endif
  229.  
  230. #if LC
  231.  
  232. #define byte char
  233.  
  234. struct XREG
  235. {
  236.     short ax,bx,cx,dx,si,di;
  237. };
  238.  
  239. struct HREG
  240. {
  241.     byte al,ah,bl,bh,cl,ch,dl,dh;
  242. };
  243.  
  244. union REGS
  245. {
  246.     struct XREG x;
  247.     struct HREG h;
  248. };
  249.  
  250. struct SREGS
  251. {
  252.     short es,cs,ss,ds;
  253. };
  254.  
  255.  
  256. extern int _stack;
  257.  
  258. struct dta dta;
  259. extern char *DRIVE;
  260.  
  261. isspace(c) char *c;{return (c == ' '||c == '\t'||c == '\n'||c == '\r');}
  262.  
  263. find_first(name)
  264. char *name;
  265. {
  266. union REGS  srv;
  267. struct SREGS rv;
  268. char  *kludge;
  269.  
  270.     set_dta();
  271.     kludge = name;
  272.     while(*kludge){
  273.         if(isspace(*kludge)) {
  274.             *kludge = NUL;
  275.             break;
  276.         }
  277.         else kludge++;
  278.     }
  279.     segread(&rv);
  280.     srv.x.cx = 0;
  281.     srv.h.ah = 0x4E;
  282.     srv.x.dx = ( unsigned )name;
  283.     return( intdosx(&srv,&srv,&rv) & 1 );
  284.  
  285. }
  286.  
  287. long now()
  288. {
  289.  
  290. union REGS srv;
  291. int    date[4];
  292. long   ldate;
  293.  
  294.     srv.x.ax = 0x2a00;            /* get system date */
  295.     intdos(&srv,&srv);
  296.     date[0] = srv.x.cx;
  297.     date[1] = srv.x.dx;
  298.     
  299.     srv.x.ax = 0x2c00;            /* get sytem time  */
  300.     intdos(&srv,&srv);
  301.     date[2] = srv.x.cx;
  302.     date[3] = srv.x.dx;
  303.     
  304.     ldate = (long)(0x7F & (date[0] - 1980)); /* year - 1980 */
  305.     ldate <<= 4;
  306.     ldate += (long)(0xF & (date[1] >> 8));   /* month */
  307.     ldate <<= 5;
  308.     ldate += (long)(0x1F & date[1]);         /* day */
  309.     ldate <<= 5;
  310.     ldate += (long)(0x1F & (date[2] >> 8));  /* hour */
  311.     ldate <<= 6;
  312.     ldate += (long)(0x3F & date[2]);         /* minute */
  313.     ldate <<= 5;
  314.     ldate += (long)(0x1E & (date[3] >> 7));  /* seconds * 2 */
  315.     return( ldate );
  316. }
  317.  
  318.  
  319. err_code() {
  320.     return(bdos(0x4d,0,0));
  321. }
  322.  
  323. find_next() {
  324.     return(bdos(0x4F,0,0));
  325. }
  326. set_dta() {
  327.     bdos(0x1A,&dta,0);
  328.     return;
  329. }
  330.  
  331. badsys(bname,code)
  332. int code;
  333. char *bname;
  334. {
  335.     error("Can't run '%s'",bname);
  336. }
  337.  
  338. baddo_sys(name,code)
  339. char *name;
  340. int code;
  341. {
  342. char temp[20];
  343.  
  344.     switch ( code ) {
  345.     
  346.         case 2:
  347.             error("File not found '%s'",name);
  348.             break;
  349.         
  350.         case 3:
  351.            error("Command too long");
  352.            break;
  353.            
  354.         case 8:
  355.            error("Not enough memory");
  356.            break;
  357.            
  358.         default:
  359.            sprintf(temp,"%d",code);
  360.            error2("DOS error %s trying to execute '%s'",temp,name);
  361.            break;
  362.     }
  363. }
  364.  
  365. do_sys(prog,args)
  366. char *prog,*args;
  367. {
  368. union REGS srv;
  369. struct SREGS rv;
  370. char cline[128],newname[128];
  371.     strcpy(newname,DRIVE);
  372.     strcat(newname,prog);
  373.     uppercase(newname); 
  374.     
  375.     if ( strlen(prog)+strlen(args) > 123 ) return( 3 );
  376.  
  377.     cline[0] = strlen(args);
  378.     strcpy(cline+1,args);   /* easier to put string in right format here */
  379.  
  380.     /* lcload expects a command processor with drive and full pathname
  381.        and the args to have the length prepended
  382.     */
  383.     return( lcload(newname,cline) );
  384.  
  385. }
  386. #endif
  387.  
  388. #if MSC
  389.  
  390. #define byte char
  391.  
  392. struct XREG
  393. {
  394.     short ax,bx,cx,dx,si,di; 
  395. };
  396.  
  397. struct HREG
  398. {
  399.     byte al,ah,bl,bh,cl,ch,dl,dh;
  400. };
  401.  
  402. union REGS
  403. {
  404.     struct XREG x;
  405.     struct HREG h;
  406. };
  407.  
  408. struct SREGS
  409. {
  410.     short es,cs,ss,ds;
  411. };
  412.  
  413. extern int _stack;
  414. struct dta dta;
  415. extern char *DRIVE;
  416.  
  417. find_first(name)
  418. char *name;
  419. {
  420. union REGS  srv;
  421. struct SREGS rv;
  422. char  *kludge;
  423.  
  424.     set_dta();
  425.     kludge = name;
  426.     while(*kludge){
  427.         if(isspace(*kludge)) {
  428.             *kludge = NUL;
  429.             break;
  430.         }
  431.         else kludge++;
  432.     }
  433.     segread(&rv);
  434.     srv.x.cx = 0;
  435.     srv.h.ah = 0x4E;
  436.     srv.x.dx = ( unsigned )name;
  437.     return( intdosx(&srv,&srv,&rv) & 1 );
  438.  
  439. }
  440.  
  441. long now()
  442. {
  443. union REGS srv;
  444. int    date[4];
  445. long   ldate;
  446.  
  447.     srv.x.ax = 0x2a00;            /* get system date */
  448.     intdos(&srv,&srv);
  449.     date[0] = srv.x.cx;
  450.     date[1] = srv.x.dx;
  451.     
  452.     srv.x.ax = 0x2c00;            /* get sytem time  */
  453.     intdos(&srv,&srv);
  454.     date[2] = srv.x.cx;
  455.     date[3] = srv.x.dx;
  456.     
  457.     ldate = (long)(0x7F & (date[0] - 1980)); /* year - 1980 */
  458.     ldate <<= 4;
  459.     ldate += (long)(0xF & (date[1] >> 8));   /* month */
  460.     ldate <<= 5;
  461.     ldate += (long)(0x1F & date[1]);         /* day */
  462.     ldate <<= 5;
  463.     ldate += (long)(0x1F & (date[2] >> 8));  /* hour */
  464.     ldate <<= 6;
  465.     ldate += (long)(0x3F & date[2]);         /* minute */
  466.     ldate <<= 5;
  467.     ldate += (long)(0x1E & (date[3] >> 7));  /* seconds * 2 */
  468.     return( ldate );
  469. }
  470.  
  471. int err_code() {
  472.     return(bdos(0x4D,0,0));
  473. }
  474.  
  475. find_next() {
  476.     return(bdos(0x4F,0,0));
  477. }
  478.  
  479. set_dta() {
  480.     bdos(0x1A,&dta,0);
  481.     return;
  482. }
  483.  
  484. badsys(bname,code)
  485. int code;
  486. char *bname;
  487. {
  488.     error("Can't run '%s'",bname);
  489. }
  490.  
  491. baddo_sys(name,code)
  492. char *name;
  493. int code;
  494. {
  495. char temp[20];
  496.  
  497.     switch ( code ) {
  498.     
  499.         case 2:
  500.             error("File not found '%s'",name);
  501.             break;
  502.         
  503.         case 3:
  504.            error("Command too long");
  505.            break;
  506.            
  507.         case 8:
  508.            error("Not enough memory");
  509.            break;
  510.            
  511.         default:
  512.            sprintf(temp,"%d",code);
  513.            error2("DOS error %s trying to execute '%s'",temp,name);
  514.            break;
  515.     }
  516. }
  517.  
  518. do_sys(prog,args,lflag)
  519. char *prog,*args;
  520. int lflag;
  521. {
  522.     char newname[128];
  523.     char clist[128];
  524.     char *clistptr;
  525.     char *arglist[100];
  526.     int i;
  527.  
  528.     strcpy(clist,args);
  529.     if (lflag)
  530.         strcpy(newname,DRIVE);
  531.     else
  532.         *newname = '\0';
  533.     strcat(newname,prog);
  534.     uppercase(newname); 
  535.     if ( strlen(prog)+strlen(args) > 123 )
  536.         return( 3 );
  537.     i = 1;
  538.     clistptr = args;
  539.     while (*clistptr){
  540.         if (!isspace(*clistptr)){
  541.             arglist[i++] = clistptr;
  542.             while (*(++clistptr) && !isspace(*clistptr)) ;
  543.         if (*clistptr)
  544.                 *clistptr = '\0';
  545.             else
  546.                 break;    
  547.         }
  548.         ++clistptr;
  549.     }
  550.     arglist[i] = NULL;
  551.     if (lflag)
  552.         return(spawnv(P_WAIT,newname,arglist));
  553.     else
  554.         return(spawnvp(P_WAIT,newname,arglist));
  555. }
  556. #endif
  557.  
  558.